home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Graphics / Utility / GL Viewer 1.1.1 / src ƒ / fades.c < prev    next >
Text File  |  1993-09-06  |  13KB  |  581 lines
  1. /*
  2.  * Mac hack of
  3.  * fades.c - grasp image fader.
  4.  *
  5.  * Copyright (c) 1991 by Patrick J. Naughton
  6.  */
  7.  
  8. #pragma segment Fades
  9.  
  10. #include <stdlib.h>
  11. #include "glassert.h"
  12. #include "grasp.h"
  13. #include "exec.h"
  14. #include "fades.h"
  15.  
  16.  
  17. extern void    exitcheck (void);
  18.  
  19.  
  20. #define FADE_SNAP    0
  21. #define FADE_WIPELR    1
  22. #define FADE_WIPERL    2
  23. #define FADE_WIPESC    3
  24. #define FADE_WIPECS    4
  25. #define FADE_ILACESIM    5
  26. #define FADE_ILACE    6
  27. #define FADE_WIPETLRBRL    7
  28. #define FADE_WIPELLRRLR    8
  29. #define FADE_WIPETB    9
  30. #define FADE_WIPEBT    10
  31. #define FADE_WIPETCBC    11
  32. #define FADE_WIPECTB    12
  33. #define FADE_ILACETBBT    13
  34. #define FADE_WIPETTBBTB    14
  35. #define FADE_WIPELTBRBT    15
  36. #define FADE_QUARTERS    16
  37. #define FADE_COLUMNS    17
  38. #define FADE_DOUBLEINT    18
  39. #define FADE_POUR    19
  40. #define FADE_SPARKLE    20
  41. #define FADE_DIAGONAL    21
  42. #define FADE_OPEN_AP    22
  43. #define FADE_CLOSE_AP    23
  44. #define FADE_CLOCK    24
  45. #define FADE_DOUBLEARC    25
  46.  
  47. #define ILACEW 16
  48. #define WIPEW 4
  49. #define DIAG_NUM_DELTA_X  16
  50.  
  51.  
  52. static void LineDDA (unsigned short a, unsigned short b, short *pPixel);
  53.  
  54.  
  55. void
  56. imagefade(fadestyle, im, xo, yo, speed, clip)
  57.     int         fadestyle;
  58.     ImageStruct *im;
  59.     int         speed;
  60.     int         xo;
  61.     int         yo;
  62.     int         clip;
  63. {
  64.     int         i;
  65.     int         j;
  66.     int         k;
  67.     int         w = im->w;
  68.     int         h = im->h;
  69.     int         halfh = (h + 1) / 2;
  70.     int         halfw = (w + 1) / 2;
  71.     int         hpar = h & 1;
  72.     int         wpar = w & 1;
  73.     Pixmap    xim  = im->pix;
  74.  
  75.  
  76.     if (((XImage *) xim)->format == TextImage)
  77.     {
  78.     int    lastattr = -1;
  79. //    XImage *xim  = XGetImage(dsp, xim, 0, 0, w, h, 0xff, ZPixmap);
  80.     XImage *pXim = (XImage *) xim;
  81.  
  82.  
  83.     if (picreg[0] /* != (ImageStruct *) NULL */)
  84.         AdjustBackgroundPic (picreg[0]->w, picreg[0]->h);
  85.     else
  86.         setvideomode ('?');
  87.  
  88.     if (im->cmap /* != (Colormap) NULL */)
  89.     {
  90.         extern Colormap    installedcmap;
  91.  
  92.  
  93.         XSetWindowColormap (dsp, win, im->cmap);
  94.         installedcmap = im->cmap;
  95.     }
  96.  
  97.     XSetBlackAndWhite (dsp, win);
  98.  
  99.     for (j = 0; j < h; j++)
  100.     {
  101. //        char       *row = "";
  102.         char       *row = &pXim->data[j * w];
  103.  
  104.  
  105.         for (i = 0; i < w / 2;)
  106.         {
  107.         char        s[81];
  108.         char        attr = 0;
  109.         short        lenStr;
  110.         short        ithChar;
  111.         char        fAllRepeats;
  112.         extern void displaystring (char *s, int x, int y);
  113.  
  114.  
  115.         k = i;
  116.  
  117.         do
  118.         {
  119.             char        attr1 = row[2 * k + 1];
  120.             char        ch = row[2 * k];
  121.  
  122.             if (ch == 0)
  123.             s[k - i] = 32;
  124.             else
  125.             {
  126.             s[k - i] = ch;
  127.             if (attr == 0)
  128.             {
  129.                 if (attr1 /* != 0 */)
  130.                 attr = attr1;
  131.             }
  132.             else if (attr != attr1)
  133.             {
  134.                 break;
  135.             }
  136.             }
  137.  
  138.             k++;
  139.  
  140.         } while (k < w / 2);
  141.  
  142.         lenStr = k - i;
  143.  
  144.         s[lenStr] = 0;
  145.  
  146.         if (attr != lastattr)
  147.         {
  148.              XSetForeground (dsp, gc, attr & 0x0f);
  149.              XSetBackground (dsp, gc, (attr >> 4) & 0x0f);
  150.             lastattr = attr;
  151.         }
  152.  
  153. //         XDrawImageString (dsp, win, gc, i * 8, (j + 1) * 13 - 1, s, lenStr);
  154.  
  155.         fAllRepeats = (lenStr > 1);
  156.  
  157.         for (ithChar = 1; ithChar < lenStr; ithChar++)
  158.         {
  159.             if (s[0] != s[ithChar])
  160.             {
  161.                 fAllRepeats = 0;
  162.                 break;
  163.             }
  164.         }
  165.  
  166.         if (!fAllRepeats)
  167.             displaystring (s, i * 8, (j + 1) * 13 - 1);
  168.  
  169.         i = k;
  170.         }
  171.     }
  172.  
  173. //    free(xim->data);
  174. //    free(xim);
  175.  
  176.     return;
  177.     }
  178.  
  179.     if (clip)
  180.         XSetClipRectangles(dsp, gc, 0, 0, &window, 1, 0);
  181.  
  182.     switch (fadestyle) {
  183.  
  184.     default:
  185.  
  186.     case FADE_SNAP:    // 0 -/
  187.     XCopyArea(dsp, xim, win, gc,
  188.           0, 0, w, h, xo, yo);
  189.     break;
  190.     
  191.     case FADE_WIPELR:    // 1 -/
  192.     for (i = 0; i < w; i += WIPEW)
  193.         XCopyArea(dsp, xim, win, gc,
  194.               i, 0, WIPEW, h, xo + i, yo);
  195.     break;
  196.  
  197.     case FADE_WIPERL:    // 2 -/
  198.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  199.         XCopyArea(dsp, xim, win, gc,
  200.               i, 0, WIPEW, h, xo + i, yo);
  201.     break;
  202.  
  203.     case FADE_WIPESC:    // 3 -/
  204.     for (i = 0; i <= halfw; i += WIPEW) {
  205.         XCopyArea(dsp, xim, win, gc,
  206.               i, 0, WIPEW, h, xo + i, yo + 0);
  207.         XCopyArea(dsp, xim, win, gc,
  208.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  209.     }
  210.     break;
  211.  
  212.     case FADE_WIPECS:    // 4 -/
  213.     for (i = halfw; i >= -WIPEW; i -= WIPEW) {
  214.         XCopyArea(dsp, xim, win, gc,
  215.               i, 0, WIPEW, h, xo + i, yo);
  216.         XCopyArea(dsp, xim, win, gc,
  217.               w - WIPEW - i, 0, WIPEW, h, xo + w - WIPEW - i, yo);
  218.     }
  219.     break;
  220.  
  221.     case FADE_ILACESIM:    // 5 -/
  222.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  223.         for (j = 0; j < h; j += 2) {
  224.         XCopyArea(dsp, xim, win, gc,
  225.               i, j, ILACEW, 1, xo + i, yo + j);
  226.         XCopyArea(dsp, xim, win, gc,
  227.               w - ILACEW - i, j + 1, ILACEW, 1,
  228.               xo + w - ILACEW - i, yo + j + 1);
  229.         }
  230.     break;
  231.  
  232.     case FADE_ILACE:    // 6 -/
  233.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  234.         for (j = 0; j < h; j += 2)
  235.         XCopyArea(dsp, xim, win, gc,
  236.               i, j, ILACEW, 1, xo + i, yo + j);
  237.     exitcheck ();
  238.     for (i = 0; i <= w - ILACEW; i += ILACEW)
  239.         for (j = 0; j < h; j += 2)
  240.         XCopyArea(dsp, xim, win, gc,
  241.               w - ILACEW - i, j + 1, ILACEW, 1,
  242.               xo + w - ILACEW - i, yo + j + 1);
  243.     break;
  244.  
  245.     case FADE_WIPETLRBRL:    // 7 -/
  246.     for (i = 0; i <= w - WIPEW; i += WIPEW)
  247.         XCopyArea(dsp, xim, win, gc,
  248.               i, halfh, WIPEW, h - halfh, xo + i, yo + halfh);
  249.     exitcheck ();
  250.     for (i = w - WIPEW; i > -WIPEW; i -= WIPEW)
  251.         XCopyArea(dsp, xim, win, gc,
  252.               i, 0, WIPEW, halfh, xo + i, yo);
  253.     break;
  254.  
  255.     case FADE_WIPELLRRLR:    // 8 -/
  256.     for (i = 0; i < halfw; i += WIPEW) {
  257.         XCopyArea(dsp, xim, win, gc,
  258.               i, 0, WIPEW, h, xo + i, yo);
  259.         XCopyArea(dsp, xim, win, gc,
  260.               halfw + i, 0, WIPEW, h, xo + halfw + i, yo);
  261.     }
  262.     break;
  263.  
  264.     case FADE_WIPETB:    // 9 -/
  265.     for (j = 0; j < h; j++)
  266.         XCopyArea(dsp, xim, win, gc,
  267.               0, j, w, 1, xo, yo + j);
  268.     break;
  269.  
  270.     case FADE_WIPEBT:    // 10 -/
  271.     for (j = h; j >= 0; j--)
  272.         XCopyArea(dsp, xim, win, gc,
  273.               0, j, w, 1, xo, yo + j);
  274.     break;
  275.  
  276.     case FADE_WIPETCBC:    // 11 -/
  277.     for (j = 0; j < halfh + hpar; j++) {
  278.         XCopyArea(dsp, xim, win, gc,
  279.               0, j, w, 1, xo, yo + j);
  280.         XCopyArea(dsp, xim, win, gc,
  281.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  282.     }
  283.     break;
  284.  
  285.     case FADE_WIPECTB:    // 12 -/
  286.     for (j = halfh + hpar - 1; j >= 0; j--) {
  287.         XCopyArea(dsp, xim, win, gc,
  288.               0, j, w, 1, xo, yo + j);
  289.         XCopyArea(dsp, xim, win, gc,
  290.               0, h - j - 1, w, 1, xo, yo + h - j - 1);
  291.     }
  292.     break;
  293.  
  294.     case FADE_ILACETBBT:    // 13 -/
  295.     for (j = 0; j < h; j += 2) {
  296.         XCopyArea(dsp, xim, win, gc,
  297.               0, j, w, 1, xo, yo + j);
  298.         XSync(dsp, False);
  299.     }
  300.     exitcheck ();
  301.     for (j = h - 1 - hpar; j > 0; j -= 2) {
  302.         XCopyArea(dsp, xim, win, gc,
  303.               0, j, w, 1, xo, yo + j);
  304.         XSync(dsp, False);
  305.     }
  306.     break;
  307.  
  308.     case FADE_WIPETTBBTB:    // 14 -/
  309.     for (j = 0; j < halfh + hpar; j++) {
  310.         XCopyArea(dsp, xim, win, gc,
  311.               0, j, w, 1, xo, yo + j);
  312.         XCopyArea(dsp, xim, win, gc,
  313.               0, halfh + j, w, 1, xo, yo + halfh + j);
  314.         XSync(dsp, False);
  315.     }
  316.     break;
  317.  
  318.     case FADE_WIPELTBRBT:    // 15 -/
  319.     for (j = 0; j < h; j++) {
  320.         XCopyArea(dsp, xim, win, gc,
  321.               0, j, halfw, 1, xo, yo + j);
  322.         XCopyArea(dsp, xim, win, gc,
  323.               halfw, h - j, halfw, 1, xo + halfw, yo + h - j);
  324.         XSync(dsp, False);
  325.     }
  326.     break;
  327.  
  328.     case FADE_QUARTERS:    // 16 -/
  329.  
  330.     // top left, top to bottom -/
  331.     for (j = 0; j <= halfh + hpar; j++) {
  332.         XCopyArea(dsp, xim, win, gc,
  333.               0, j, halfw + wpar, 1, xo, yo + j);
  334.         XSync(dsp, False);
  335.     }
  336.     exitcheck ();
  337.  
  338.     // bottom right, top to bottom -/
  339.     for (j = halfh + hpar; j < h; j++) {
  340.         XCopyArea(dsp, xim, win, gc,
  341.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  342.         XSync(dsp, False);
  343.     }
  344.     exitcheck ();
  345.  
  346.     // bottom left, bottom to top -/
  347.     for (j = h; j >= halfh; j--) {
  348.         XCopyArea(dsp, xim, win, gc,
  349.               0, j, halfw + wpar, 1, xo, yo + j);
  350.         XSync(dsp, False);
  351.     }
  352.     exitcheck ();
  353.  
  354.     // top right, bottom to top -/
  355.     for (j = halfh; j >= 0; j--) {
  356.         XCopyArea(dsp, xim, win, gc,
  357.               halfw + wpar, j, halfw, 1, xo + halfw + wpar, yo + j);
  358.         XSync(dsp, False);
  359.     }
  360.     break;
  361.  
  362.     case FADE_COLUMNS:    // 17 -/
  363.     for (j = 0; j < h; j += 2)
  364.         for (i = 0; i < w; i += 16)
  365.         XCopyArea(dsp, xim, win, gc,
  366.               i, j, 8, 2, xo + i, yo + j);
  367.     exitcheck ();
  368.  
  369.     for (j = h - 1; j >= -1; j -= 2)
  370.         for (i = 8; i < w; i += 16)
  371.         XCopyArea(dsp, xim, win, gc,
  372.               i, j, 8, 2, xo + i, yo + j);
  373.  
  374.     break;
  375.  
  376.     case FADE_DOUBLEINT:    // 18 -/
  377.     for (j = 0; j < h; j += 2)
  378.         for (i = 0; i < w; i += 16)
  379.         XCopyArea(dsp, xim, win, gc,
  380.               i, j, 8, 1, xo + i, yo + j);
  381.     exitcheck ();
  382.     for (j = h - 1; j >= 0; j -= 2)
  383.         for (i = 8; i < w; i += 16)
  384.         XCopyArea(dsp, xim, win, gc,
  385.               i, j, 8, 1, xo + i, yo + j);
  386.     exitcheck ();
  387.     for (j = 1; j < h; j += 2)
  388.         for (i = 0; i < w; i += 16)
  389.         XCopyArea(dsp, xim, win, gc,
  390.               i, j, 8, 1, xo + i, yo + j);
  391.     exitcheck ();
  392.     for (j = h - 2; j >= 0; j -= 2)
  393.         for (i = 8; i < w; i += 16)
  394.         XCopyArea(dsp, xim, win, gc,
  395.               i, j, 8, 1, xo + i, yo + j);
  396.     break;
  397.  
  398.     case FADE_POUR:    // 19 -/
  399.     for (j = h - 1; j >= 0; j -= WIPEW)
  400.     {
  401.         for (i = 0; i < j; i++)
  402.         XCopyArea(dsp, xim, win, gc,
  403.               0, j, w, WIPEW, xo + 0, yo + i);
  404.         exitcheck ();
  405.     }
  406.     break;
  407.  
  408.     case FADE_SPARKLE:    // 20 -/
  409.     {
  410.         int         boxsize = (w + 19) / 20; //(w + 39) / 40;
  411.         int         cols = (w + (boxsize - 1)) / boxsize;
  412.         int         boxcount = (h + (boxsize - 1)) / boxsize * cols;
  413.         int        *order = (int *) malloc((size_t) boxcount * sizeof(int));
  414.  
  415.  
  416.         assert (order);
  417.  
  418.         (void) srand(getpid());
  419.         for (i = 0; i < boxcount; i++)
  420.         order[i] = i;
  421.         for (i = 0; i < boxcount * boxsize; i++) {
  422.         int         i1 = rand() % boxcount;
  423.         int         i2 = rand() % boxcount;
  424.         j = order[i1];
  425.         order[i1] = order[i2];
  426.         order[i2] = j;
  427.         }
  428.         exitcheck ();
  429.         for (i = 0; i < boxcount; i++) {
  430.         int         x = (order[i] % cols) * boxsize;
  431.         int         y = (order[i] / cols) * boxsize;
  432.         XCopyArea(dsp, xim, win, gc,
  433.               x, y, boxsize, boxsize, xo + x, yo + y);
  434.         }
  435.         free(order);
  436.     }
  437.     break;
  438.  
  439.     case FADE_DIAGONAL:    // 21 -/
  440.     {
  441.         short    maxDim = (w > h) ? w : h;
  442.         short    delta  = maxDim / DIAG_NUM_DELTA_X;
  443.         short   x1;
  444.         short   x2;
  445.     
  446.     
  447.         for (x1 = -maxDim, x2 = x1 + delta;
  448.              x1 < maxDim;
  449.              x1 += delta, x2 += delta)
  450.         {
  451.             for (i = 0; i < maxDim; i++)
  452.             {
  453.                 short   xx1 = x1 + i;
  454.                 short   xx2 = x2 + i;
  455.  
  456.  
  457.                 if (xx1 < 0)
  458.                     xx1 = 0;
  459.                 if (xx2 < 0)
  460.                     xx2 = 0;
  461.     
  462.                 if (xx1 > w)
  463.                     xx1 = w;
  464.                 if (xx2 > w)
  465.                     xx2 = w;
  466.     
  467.                 if (xx1 < xx2)
  468.                 {
  469.                     short   y = maxDim - i;
  470.     
  471.  
  472.             if (y < 0 || y > h)
  473.                 continue;
  474.  
  475.                     XCopyArea (dsp, xim, win, gc,
  476.                                xx1, y, xx2 - xx1, 1, xx1, y);
  477.                 }
  478.             }
  479.  
  480.         exitcheck ();
  481.         }
  482.  
  483.         break;
  484.     }
  485.  
  486.     case FADE_OPEN_AP:    // 22 -/
  487.     for (i = 0; i <= MAX(w, h) / 2; i += WIPEW) {
  488.         // left wedge -/
  489.         XCopyArea(dsp, xim, win, gc,
  490.               halfw - i, halfh - i, WIPEW, 2 * i,
  491.               xo + halfw - i, yo + halfh - i);
  492.         // top wedge -/
  493.         XCopyArea(dsp, xim, win, gc,
  494.               halfw - i, halfh - i, 2 * i, WIPEW,
  495.               xo + halfw - i, yo + halfh - i);
  496.         // right wedge -/
  497.         XCopyArea(dsp, xim, win, gc,
  498.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  499.               xo + halfw + i, yo + halfh - i);
  500.         // bottom wedge -/
  501.         XCopyArea(dsp, xim, win, gc,
  502.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  503.               xo + halfw - i, yo + halfh + i);
  504.         XSync(dsp, False);
  505.     }
  506.     break;
  507.  
  508.     case FADE_CLOSE_AP:    // 23 -/
  509.     for (i = MAX(w, h) / 2; i >= 0; i -= WIPEW) {
  510.         // left wedge -/
  511.         XCopyArea(dsp, xim, win, gc,
  512.               halfw - i, halfh - i, WIPEW, 2 * i,
  513.               xo + halfw - i, yo + halfh - i);
  514.         // top wedge -/
  515.         XCopyArea(dsp, xim, win, gc,
  516.               halfw - i, halfh - i, 2 * i, WIPEW,
  517.               xo + halfw - i, yo + halfh - i);
  518.         // right wedge -/
  519.         XCopyArea(dsp, xim, win, gc,
  520.               halfw + i, halfh - i, WIPEW, 2 * i + WIPEW,
  521.               xo + halfw + i, yo + halfh - i);
  522.         // bottom wedge -/
  523.         XCopyArea(dsp, xim, win, gc,
  524.               halfw - i, halfh + i, 2 * i + WIPEW, WIPEW,
  525.               xo + halfw - i, yo + halfh + i);
  526.         XSync(dsp, False);
  527.     }
  528.     break;
  529.  
  530.     case FADE_CLOCK:    // 24 -/// not implemented -/
  531.     XCopyArea(dsp, xim, win, gc,
  532.           0, 0, w, h, xo, yo);
  533.     break;
  534.  
  535.     case FADE_DOUBLEARC:    // 25 -/// not implemented -/
  536.     XCopyArea(dsp, xim, win, gc,
  537.           0, 0, w, h, xo, yo);
  538.     break;
  539.  
  540.     }
  541.     XSetClipMask(dsp, gc, None);
  542.     XSync(dsp, False);
  543. }
  544.  
  545.  
  546. /*
  547.  * Bresenham's line Digital Differential Analyzer (DDA)
  548.  *
  549.  * a >= b > 0, pPixel = (short *) malloc (sizeof (short) * a)
  550.  *
  551.  */
  552.  
  553.     static void
  554. LineDDA (unsigned short a, unsigned short b, short *pPixel)
  555.  
  556. {
  557.     unsigned short  x = 0;
  558.     unsigned short  y = 0;
  559.     short           d = b - (a >> 1);
  560.     short           stride = b - a;
  561.     unsigned short  i;
  562.  
  563.  
  564.     for (i = 0; i < a; i++)
  565.     {
  566.         *pPixel++ = y;
  567.  
  568.         if (d < 0)
  569.         {
  570.             x++;
  571.             d += b;
  572.         }
  573.         else
  574.         {
  575.             x++;
  576.             y++;
  577.             d += stride;
  578.         }
  579.     }
  580. }
  581.